BatchGenerator.__init__ already calls mx.set_wired_limit() on each
instance, and concurrent calls with the same value are race-free
(verified empirically). The guard never prevented the race it claimed
to fix.

Follow-up to #1304.

mlx-vlm's load() only materializes model.language_model.parameters(), leaving frozen buffers (RoPE freqs) and sibling sub-trees (vision_tower, audio_tower) as lazy arrays bound to the loader thread's default stream. Pre-#1304 this was invisible because loader and forward shared one global thread; the per-engine executor split exposed it as "no Stream(gpu, X) in current thread" when mx.eval touches a sibling buffer during prefill.

Fix: materialize the full model tree on the loader thread right after load. Verified against gemma-4-E2B-it and gemma-4-31b-it-4bit.

Also fixes test_safe_sync_passes_generation_stream to match the _default_generation_stream alias introduced by #1304.

Reported by @zviratko in #1304.

)

#1304 (``fix(engine): per-engine threads to eliminate cross-engine
stream contamination``) refactored the patched ``BatchGenerator`` to
inherit its execution stream from the enclosing engine context, and
removed the module-level ``_get_generation_stream`` helper as part of
that. ``TestBatchGeneratorDispatch._make_reconcile_batch`` still tried
to monkeypatch that name and failed at collection of every test that
depends on the fixture with ``AttributeError: module ... has no
attribute '_get_generation_stream'`` — taking down 4 reconcile-path
tests on every CI run.

The override is no longer needed: the surrounding fixture replaces
``_rebuild_singleton_cache`` and ``_call_backbone`` with fakes that
do all of their work via ``np.array`` / ``mx.array`` directly, so
neither MLX dispatch nor stream selection is reached.

Tests (tests/test_mlx_lm_mtp_patch.py::TestBatchGeneratorDispatch):
- test_reconcile_uses_queue_front_as_next_token
- test_reconcile_empty_queue_samples_from_logits
- test_reconcile_returns_false_on_empty_tokens
- test_reconcile_fallback_on_rebuild_failure

11/11 TestBatchGeneratorDispatch tests pass.

Catch-up sync. Highlights:
- boundary-store cleanup race fix (jundot#1423) — eliminates the
  test_cleanup_all_drains_queue flake we have been carrying.
- per-engine MLX threads / streams (jundot#1304) — multiple models stepping
  scheduler.step() concurrently no longer cross-contaminate streams.
- VLM lazy state materialized on loader thread; skip MTPModule attach
  when checkpoint lacks mtp.* weights.
- Dead TieredCacheManager removed; profiles three-scope template
  refactor (jundot#1399).

4567 pass / 3 known env-override fails / 36 skip. Zero regression.
User delegated review.

---

Catch-up 同步. 主要内容:
- boundary-store 清理 race 修复 (jundot#1423) - 消掉一直拖着的
  test_cleanup_all_drains_queue flake.
- 每引擎 MLX 线程 / 流 (jundot#1304) - 多模型并发 scheduler.step()
  不再 cross-contaminate.
- VLM 在 loader 线程实例化 lazy 状态; checkpoint 无 mtp.* 权重时
  跳过 MTPModule attach.
- 删 dead TieredCacheManager; profiles three-scope template 重构
  (jundot#1399).

4567 pass / 3 known env-override fails / 36 skip. 零回归.
用户委托 review.

Same root cause and fix as e93c408 for the VLM MTP drafter, applied
to the SpecPrefill draft load path in both BatchedEngine and
VLMBatchedEngine.

`mlx_lm.load(specprefill_draft)` materializes only model.parameters()
via mx.eval and leaves frozen buffers (RoPE freqs, masked_embedding
tables, etc.) lazy, bound to the global mlx loader thread's stream.
The draft model is then stored on `Scheduler._specprefill_draft_model`
and later read from `score_tokens(self._specprefill_draft_model, ...)`
at scheduler.py:4247, which runs on the per-engine executor's worker
thread. The first SpecPrefill-eligible prefill raises
``no Stream(gpu, X) in current thread`` because `mx.async_eval` on the
inference thread tries to materialize lazy ops against a stream that
does not exist there.

Call materialize_lazy_state(draft_model) inside _load_draft (which
runs on get_mlx_executor()) right before returning, so every leaf
array is concrete before any inference thread reads it. The VLM
helper also refactors the dual-return into a single materialize+return
to cover both the custom_quantization and standard mlx_lm.load paths.

Closes the SpecPrefill instance of the jundot#1304 per-engine-threads bug
class identified after 9d5bed8 (main VLM model), e93c408 (VLM MTP
drafter), and 9407468 (boundary snapshots).

Not directly testable without running SpecPrefill against a per-engine
configuration, but matches the merged e93c408 pattern exactly.

Same root cause and fix as e93c408 for the VLM MTP drafter, applied
to the SpecPrefill draft load path in both BatchedEngine and
VLMBatchedEngine.

`mlx_lm.load(specprefill_draft)` materializes only model.parameters()
via mx.eval and leaves frozen buffers (RoPE freqs, masked_embedding
tables, etc.) lazy, bound to the global mlx loader thread's stream.
The draft model is then stored on `Scheduler._specprefill_draft_model`
and later read from `score_tokens(self._specprefill_draft_model, ...)`
at scheduler.py:4247, which runs on the per-engine executor's worker
thread. The first SpecPrefill-eligible prefill raises
``no Stream(gpu, X) in current thread`` because `mx.async_eval` on the
inference thread tries to materialize lazy ops against a stream that
does not exist there.

Call materialize_lazy_state(draft_model) inside _load_draft (which
runs on get_mlx_executor()) right before returning, so every leaf
array is concrete before any inference thread reads it. The VLM
helper also refactors the dual-return into a single materialize+return
to cover both the custom_quantization and standard mlx_lm.load paths.

Closes the SpecPrefill instance of the jundot#1304 per-engine-threads bug
class identified after 9d5bed8 (main VLM model), e93c408 (VLM MTP
drafter), and 9407468 (boundary snapshots).

Not directly testable without running SpecPrefill against a per-engine
configuration, but matches the merged e93c408 pattern exactly.

Same root cause and fix as e93c408 for the VLM MTP drafter, applied
to the SpecPrefill draft load path in both BatchedEngine and
VLMBatchedEngine.

`mlx_lm.load(specprefill_draft)` materializes only model.parameters()
via mx.eval and leaves frozen buffers (RoPE freqs, masked_embedding
tables, etc.) lazy, bound to the global mlx loader thread's stream.
The draft model is then stored on `Scheduler._specprefill_draft_model`
and later read from `score_tokens(self._specprefill_draft_model, ...)`
at scheduler.py:4247, which runs on the per-engine executor's worker
thread. The first SpecPrefill-eligible prefill raises
``no Stream(gpu, X) in current thread`` because `mx.async_eval` on the
inference thread tries to materialize lazy ops against a stream that
does not exist there.

Call materialize_lazy_state(draft_model) inside _load_draft (which
runs on get_mlx_executor()) right before returning, so every leaf
array is concrete before any inference thread reads it. The VLM
helper also refactors the dual-return into a single materialize+return
to cover both the custom_quantization and standard mlx_lm.load paths.

Closes the SpecPrefill instance of the jundot#1304 per-engine-threads bug
class identified after 9d5bed8 (main VLM model), e93c408 (VLM MTP
drafter), and 9407468 (boundary snapshots).

Not directly testable without running SpecPrefill against a per-engine
configuration, but matches the merged e93c408 pattern exactly.

Same root cause and fix as e93c408 for the VLM MTP drafter, applied
to the SpecPrefill draft load path in both BatchedEngine and
VLMBatchedEngine.

`mlx_lm.load(specprefill_draft)` materializes only model.parameters()
via mx.eval and leaves frozen buffers (RoPE freqs, masked_embedding
tables, etc.) lazy, bound to the global mlx loader thread's stream.
The draft model is then stored on `Scheduler._specprefill_draft_model`
and later read from `score_tokens(self._specprefill_draft_model, ...)`
at scheduler.py:4247, which runs on the per-engine executor's worker
thread. The first SpecPrefill-eligible prefill raises
``no Stream(gpu, X) in current thread`` because `mx.async_eval` on the
inference thread tries to materialize lazy ops against a stream that
does not exist there.

Call materialize_lazy_state(draft_model) inside _load_draft (which
runs on get_mlx_executor()) right before returning, so every leaf
array is concrete before any inference thread reads it. The VLM
helper also refactors the dual-return into a single materialize+return
to cover both the custom_quantization and standard mlx_lm.load paths.

Closes the SpecPrefill instance of the jundot#1304 per-engine-threads bug
class identified after 9d5bed8 (main VLM model), e93c408 (VLM MTP
drafter), and 9407468 (boundary snapshots).

Not directly testable without running SpecPrefill against a per-engine
configuration, but matches the merged e93c408 pattern exactly.

Same root cause and fix as e93c408 for the VLM MTP drafter, applied
to the SpecPrefill draft load path in both BatchedEngine and
VLMBatchedEngine.

`mlx_lm.load(specprefill_draft)` materializes only model.parameters()
via mx.eval and leaves frozen buffers (RoPE freqs, masked_embedding
tables, etc.) lazy, bound to the global mlx loader thread's stream.
The draft model is then stored on `Scheduler._specprefill_draft_model`
and later read from `score_tokens(self._specprefill_draft_model, ...)`
at scheduler.py:4247, which runs on the per-engine executor's worker
thread. The first SpecPrefill-eligible prefill raises
``no Stream(gpu, X) in current thread`` because `mx.async_eval` on the
inference thread tries to materialize lazy ops against a stream that
does not exist there.

Call materialize_lazy_state(draft_model) inside _load_draft (which
runs on get_mlx_executor()) right before returning, so every leaf
array is concrete before any inference thread reads it. The VLM
helper also refactors the dual-return into a single materialize+return
to cover both the custom_quantization and standard mlx_lm.load paths.

Closes the SpecPrefill instance of the jundot#1304 per-engine-threads bug
class identified after 9d5bed8 (main VLM model), e93c408 (VLM MTP
drafter), and 9407468 (boundary snapshots).

Not directly testable without running SpecPrefill against a per-engine
configuration, but matches the merged e93c408 pattern exactly.

…#1485)

Same root cause and fix as e93c408 for the VLM MTP drafter, applied
to the SpecPrefill draft load path in both BatchedEngine and
VLMBatchedEngine.

`mlx_lm.load(specprefill_draft)` materializes only model.parameters()
via mx.eval and leaves frozen buffers (RoPE freqs, masked_embedding
tables, etc.) lazy, bound to the global mlx loader thread's stream.
The draft model is then stored on `Scheduler._specprefill_draft_model`
and later read from `score_tokens(self._specprefill_draft_model, ...)`
at scheduler.py:4247, which runs on the per-engine executor's worker
thread. The first SpecPrefill-eligible prefill raises
``no Stream(gpu, X) in current thread`` because `mx.async_eval` on the
inference thread tries to materialize lazy ops against a stream that
does not exist there.

Call materialize_lazy_state(draft_model) inside _load_draft (which
runs on get_mlx_executor()) right before returning, so every leaf
array is concrete before any inference thread reads it. The VLM
helper also refactors the dual-return into a single materialize+return
to cover both the custom_quantization and standard mlx_lm.load paths.

Closes the SpecPrefill instance of the #1304 per-engine-threads bug
class identified after 9d5bed8 (main VLM model), e93c408 (VLM MTP
drafter), and 9407468 (boundary snapshots).

Not directly testable without running SpecPrefill against a per-engine
configuration, but matches the merged e93c408 pattern exactly.

…amination (jundot#1304)

Replace the shared _global_mlx_executor with per-EngineCore
ThreadPoolExecutor + mx.Stream, and fix the MTP patch reading the
module-level generation_stream instead of the per-engine stream.

BatchGenerator.__init__ already calls mx.set_wired_limit() on each
instance, and concurrent calls with the same value are race-free
(verified empirically). The guard never prevented the race it claimed
to fix.

Follow-up to jundot#1304.

mlx-vlm's load() only materializes model.language_model.parameters(), leaving frozen buffers (RoPE freqs) and sibling sub-trees (vision_tower, audio_tower) as lazy arrays bound to the loader thread's default stream. Pre-jundot#1304 this was invisible because loader and forward shared one global thread; the per-engine executor split exposed it as "no Stream(gpu, X) in current thread" when mx.eval touches a sibling buffer during prefill.

Fix: materialize the full model tree on the loader thread right after load. Verified against gemma-4-E2B-it and gemma-4-31b-it-4bit.

Also fixes test_safe_sync_passes_generation_stream to match the _default_generation_stream alias introduced by jundot#1304.

Reported by @zviratko in jundot#1304.

…ndot#1445)

jundot#1304 (``fix(engine): per-engine threads to eliminate cross-engine
stream contamination``) refactored the patched ``BatchGenerator`` to
inherit its execution stream from the enclosing engine context, and
removed the module-level ``_get_generation_stream`` helper as part of
that. ``TestBatchGeneratorDispatch._make_reconcile_batch`` still tried
to monkeypatch that name and failed at collection of every test that
depends on the fixture with ``AttributeError: module ... has no
attribute '_get_generation_stream'`` — taking down 4 reconcile-path
tests on every CI run.

The override is no longer needed: the surrounding fixture replaces
``_rebuild_singleton_cache`` and ``_call_backbone`` with fakes that
do all of their work via ``np.array`` / ``mx.array`` directly, so
neither MLX dispatch nor stream selection is reached.

Tests (tests/test_mlx_lm_mtp_patch.py::TestBatchGeneratorDispatch):
- test_reconcile_uses_queue_front_as_next_token
- test_reconcile_empty_queue_samples_from_logits
- test_reconcile_returns_false_on_empty_tokens
- test_reconcile_fallback_on_rebuild_failure

11/11 TestBatchGeneratorDispatch tests pass.

…jundot#1485)

Same root cause and fix as e93c408 for the VLM MTP drafter, applied
to the SpecPrefill draft load path in both BatchedEngine and
VLMBatchedEngine.

`mlx_lm.load(specprefill_draft)` materializes only model.parameters()
via mx.eval and leaves frozen buffers (RoPE freqs, masked_embedding
tables, etc.) lazy, bound to the global mlx loader thread's stream.
The draft model is then stored on `Scheduler._specprefill_draft_model`
and later read from `score_tokens(self._specprefill_draft_model, ...)`
at scheduler.py:4247, which runs on the per-engine executor's worker
thread. The first SpecPrefill-eligible prefill raises
``no Stream(gpu, X) in current thread`` because `mx.async_eval` on the
inference thread tries to materialize lazy ops against a stream that
does not exist there.

Call materialize_lazy_state(draft_model) inside _load_draft (which
runs on get_mlx_executor()) right before returning, so every leaf
array is concrete before any inference thread reads it. The VLM
helper also refactors the dual-return into a single materialize+return
to cover both the custom_quantization and standard mlx_lm.load paths.

Closes the SpecPrefill instance of the jundot#1304 per-engine-threads bug
class identified after 9d5bed8 (main VLM model), e93c408 (VLM MTP
drafter), and 9407468 (boundary snapshots).

Not directly testable without running SpecPrefill against a per-engine
configuration, but matches the merged e93c408 pattern exactly.